package model;

import java.util.ArrayList;

/**
 *
 * @author Antoine Thorr, Joana Santos, Samy Rida, Vicky Ngo Pagbe
 */
public class IA extends Joueur {

  private ArrayList<CarteOffensive> posablesAtt;
  private CarteOffensive posableAtt;
  private ArrayList<CarteDefensive> posablesDef;
  private CarteDefensive posableDef;
  private ArrayList<CarteOffensive> attaquantes;
  private ArrayList<Carte> attaquables;
//  private Joueur adversaire;

  /**
   *
   * @param deck2
   */
  public IA(Pile deck2) {
    super(deck2);
  }

  /**
   *
   */
  public void poseCarte() {
    while (this.getRessourceTemp() > 0) { //Tant qu'il reste des ressources
      this.posablesAtt = new ArrayList<>(); //Obligé de recréer une arraylist à chaque fois car cartes posées supprimées de la main, ou d'itérer avec un itérateur éventuellement
      this.posablesDef = new ArrayList<>();
      for (Carte c : this.getMain().getMain()) { //Remplissage d'un arraylist de cartes posables (en termes de ressources)
        if (c.getCout() <= this.getRessourceTemp()) {
          switch (c.getAttitude()) {
            case "offensive":
              if (this.getPartieTerrain().nbAttaque() < 5) {
                this.posablesAtt.add((CarteOffensive) c);
              }
              break;
            case "defensive":
              if (this.getPartieTerrain().nbDefense() < 5) {
                this.posablesDef.add((CarteDefensive) c);
              }
              break;
          }
        }
      }
      if (!this.posablesAtt.isEmpty()) { //S'il reste des cartes posables
        this.posableAtt = this.choixCarteOffensivePosable();
        this.poserCarteOffensive(this.posableAtt); //On pose aléatoirement une des cartes attaque
      } else if (!this.posablesDef.isEmpty()) {
        this.posableDef = this.choixCarteDefensivePosable();
        this.poserCarteDefensive(this.posableDef); //On pose aléatoirement une des cartes défense
      } else {
        break; //Sinon on sort du while
      }
    }
  }

  /**
   *
   * @return
   */
  public CarteOffensive choixCarteOffensivePosable() {
    //TODO - Faire système de sélection intelligente (dans un premier temps, envoie carte du même type que le joueur ?)
    int aleat = (int) (Math.random() * this.posablesAtt.size()); //Sélection aléatoire de la carte parmi les possibles
    return this.posablesAtt.get(aleat);
  }

  /**
   *
   * @return
   */
  public CarteDefensive choixCarteDefensivePosable() {
    //TODO - Faire système de sélection intelligente (dans un premier temps, envoie carte du même type que le joueur ?)
    int aleat = (int) (Math.random() * this.posablesDef.size()); //Sélection aléatoire de la carte parmi les possibles
    return this.posablesDef.get(aleat);
  }

  /**
   *
   * @param j
   * @return
   */
  public boolean peutAttaquer(Joueur j) {
    this.attaquantes = new ArrayList<>();
    if (this.getPartieTerrain().nbAttaque() > 0) {
      //System.out.println("Taille getAttaque : " + this.getPartieTerrain().nbAttaque());
      for (CarteOffensive c : this.getPartieTerrain().getAttaque()) { //Remplissage d'un arraylist de cartes d'attaque (en termes de ressources)
        if (c != null) {
          if (c.getEtat() == Etat.enAttente) {
            //System.out.println("AJOUT ATTAQUANTE : " + c.getNom());
            this.attaquantes.add((CarteOffensive) c);
          }
        }
      }
    }

    this.attaquables = new ArrayList<>();
    if (j.getPartieTerrain().getCartes().length > 0) {
      for (Carte c : j.getPartieTerrain().getCartes()) { //Remplissage d'un arraylist de cartes attaquables (en termes de ressources)
        if (c != null) {
          //System.out.println("AJOUT ATTAQUABLE : " + c.getNom());
          this.attaquables.add(c); //pour l'instant, attaque de toutes les cartes random, pas que la défense adverse
        }
      }
    }

    return !this.attaquantes.isEmpty() && !this.attaquables.isEmpty(); //Pour l'instant l'IA n'attaque pas les PV, la condition se fait que sur les cartes
  }

  /**
   *
   * @return
   */
  public CarteOffensive choixCarteAttaquante() {
    //TODO - Faire système de sélection intelligente (dans un premier temps, sélectionne le plus)
    int aleat = (int) Math.floor(Math.random() * this.attaquantes.size()); //Sélection aléatoire de la carte parmi les possibles
    return (CarteOffensive) this.attaquantes.get(aleat);
  }

  /**
   *
   * @return
   */
  public Carte choixCarteAttaquable() {
    //TODO - Faire système de sélection intelligente (dans un premier temps, attaque le plus faible ?)
    int aleat = (int) Math.floor(Math.random() * this.attaquables.size()); //Sélection aléatoire de la carte parmi les possibles
    return this.attaquables.get(aleat);
  }

  /**
   *
   * @param j
   * @return
   */
  public boolean peutAttaquerJoueur(Joueur j) { //Fonction de toute façon appelée après la 1e, qui remplie l'arraylist des attaquantes
    if (this.attaquantes.isEmpty()) { //S'il n'y a pas d'attaquantes, on ne peut pas attaquer le joueur
      return false;
    }
    return j.getPartieTerrain().nbDefense() == 0; //Et s'il n'y a pas de défense côté joueur, on ne peut pas l'attaquer directement non plus
  }

  /**
   *
   * @return
   */
  @Override
  public String getNomClasse() {
    return "IA";
  }
}
